// /*
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Library General Public
//    License version 2 as published by the Free Software Foundation.
// 
//    This library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Library General Public License for more details.
// 
//    You should have received a copy of the GNU Library General Public License
//    along with this library; see the file COPYING.LIB.  If not, write to
//    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
//    Boston, MA 02110-1301, USA.
// */
// 
// #include "function.h"
// #include <QDebug>
// #include "muparser/muParser.h"
// #include "ifunction.h"
// #include "parserfactory.h"
// 
// Math::Function2D::Function2D( const std::string & _equation) : 
//   m_Equation(_equation) ,
// //   m_apMatrixOfValues( NULL ),
//   m_SizeOfArrays(0),
//   m_NeedToRecalculate(false)
// {
//     if ( ! _equation.empty() ) 
//         setEquation( _equation ) ; // to switch function type to cintinous
//         
//     Math2::IFunction<double> fun ; 
//     fun.value(-1);
// }
// Math::Function2D::~Function2D() {
// }
// double Math::Function2D::value( double _x ) const {
//     try{
//         if ( m_Type == Math::eUnknown ) 
//             return -1 ; 
//         else if ( m_Type == Math::eContinuous ) 
//             return m_Parser.evaluate( _x );
//     }
//     catch ( mu::Parser::exception_type & ex ) {
//         throw Math::FunctionException(ex.GetMsg());
//     }
//     catch ( std::domain_error & err ) {
//         throw Math::FunctionException( err.what() );
//     }
//     return -1 ; 
// }
// void Math::Function2D::setEquation(const std::string& _equation) {
//     ///TODO: check if _equation has 'x' 
//     ///TODO: check if _equation is valid function definition
//     m_Equation = _equation ; 
//     m_Parser.setEquation( m_Equation );
//     m_Type = Math::eContinuous;
//     m_NeedToRecalculate = true ; 
// }
// /// Function2D::Parser impl
// Math::Function2D::Parser::Parser(const std::string& _equation) : m_pParser ( Math::ParserFactory::factory() )  {
//     m_pParser->SetExpr( _equation );
//     m_pParser->DefineVar("x",&m_fVal);
// }
// Math::Function2D::Parser::~Parser() {
// }
// 
// void Math::Function2D::Parser::setEquation(const std::string& _equation) {
//     m_pParser->SetExpr( _equation );
//     m_pParser->DefineVar("x",&m_fVal);
// }
// double Math::Function2D::Parser::evaluate(double _x) const{
//     m_fVal = _x ; 
//     double ret ; 
//     ret = m_pParser->Eval();
//     return ret ; 
// }
// void Math::Function2D::recalculateData( int _size, double _xMin, double _xMax, double _step ) {
//     
//     m_NeedToRecalculate = false  ;
// }
// void Math::Function2D::setData(double* _pX, double* _pY, int _size) {
//     Q_CHECK_PTR(_pX);
//     Q_CHECK_PTR(_pY);
//     m_Type = Math::eDiscrete ;
//     m_Xs.reset(_pX);
//     m_Ys.reset(_pY);
//     m_SizeOfArrays = _size ; 
//     m_Equation = "";
//     m_NeedToRecalculate = true; 
// }
// Math::Function2D* Math::Function2D::calculateDerivative(double _startX, double _stopX, double _step, Math::DerivativeMethod _dMethod) const {
//     // TODO: sprawdzić czy mamy postać funkcji ztablicowaną czy nie. 
//     Math::Function2D * pFunction = new Math::Function2D() ; 
//     double *pX;
//     double *pY;
//     int howManyPoints = (int) ( (abs(_startX) + abs(_stopX))/_step );
//     pX = new double [ howManyPoints ];
//     pY = new double [ howManyPoints ];
//     double iterator = _startX ;  
//     double fx ;
//     double fxWithH ; 
//     for (int i = 0 ; i < howManyPoints ; ++i) {
//         fx = value(iterator);
//         fxWithH = value( iterator + _step ) ;
//         pX[i] = iterator ; 
//         pY[i] = (fxWithH - fx)/_step ; 
//     }
//     pFunction->setData(pX,pY,howManyPoints);
//     return pFunction ; 
// }
// 
